//AL5958_AL5958Q_Arduino code used in the AL5958QEV1 demo board


// Hardware reLatched definitions ****************************************************************************************
#define ChannelQty 48        // Quantity of ChannelQtys
#define ScanQty 16           // Quantity of scanning
#define Do0 A11              // Gck0 set to Arduino digit pin 2
#define Gck0 2               // Gck0 set to Arduino digit pin 2
#define Di0 4                // Di0 set to Arduino digit pin 4
#define Dck0 6               // Dck0 set to Arduino digit pin 6
#define Latch0 7             // Latch0 set to Arduino digit pin 7
#define _MCUDo0 0            // Di0 set to ATMEGA2560 Port G pin 5 Arduino digit pin 4 (Used for fast I/O task requirements)
#define _MCUDi0 5            // Di0 set to ATMEGA2560 Port G pin 5 Arduino digit pin 4 (Used for fast I/O task requirements)
#define _MCUDck0 3           // Dck0 set to ATMEGA2560 Port H pin 3 Arduino digit pin 6 (Used for fast I/O task requirements)
#define _MCULatch0 4         // Latch0 set to ATMEGA2560 Port H pin 4 Arduino digit pin 7 (Used for fast I/O task requirements)
#define CMD3_12 3            // RCMD3[12] set to Arduino digit pin 3
#define CMD3_13 5            // RCMD3[13] set to Arduino digit pin 5
#define RCMD20 8             // RCMD2[0] set to Arduino digit pin 8
#define RCMD21 9             // RCMD2[1] set to Arduino digit pin 9
#define GCMD20 10            // GCMD2[0] set to Arduino digit pin 10
#define GCMD21 11            // GCMD2[1] set to Arduino digit pin 11
#define BCMD20 12            // BCMD2[0] set to Arduino digit pin 12
#define BCMD21 13            // BCMD2[0] set to Arduino digit pin 13
#define RGCC5 14             // RGCC set to Arduino digit pin 14
#define RGCC4 15             // RGCC set to Arduino digit pin 15
#define RGCC3 16             // RGCC set to Arduino digit pin 16
#define RGCC2 17             // RGCC set to Arduino digit pin 17
#define RGCC1 18             // RGCC set to Arduino digit pin 18
#define RGCC0 19             // RGCC set to Arduino digit pin 19
#define GGCC5 20             // GGCC set to Arduino digit pin 20
#define GGCC4 21             // GGCC set to Arduino digit pin 21
#define GGCC3 22             // GGCC set to Arduino digit pin 22
#define GGCC2 23             // GGCC set to Arduino digit pin 23
#define GGCC1 24             // GGCC set to Arduino digit pin 24
#define GGCC0 25             // GGCC set to Arduino digit pin 25
#define BGCC5 26             // BGCC set to Arduino digit pin 26
#define BGCC4 27             // BGCC set to Arduino digit pin 27
#define BGCC3 28             // BGCC set to Arduino digit pin 28
#define BGCC2 29             // BGCC set to Arduino digit pin 29
#define BGCC1 30             // BGCC set to Arduino digit pin 30
#define BGCC0 31             // BGCC set to Arduino digit pin 31
#define RedSelect 8          // 红光恒亮开关接口
#define YellowSelect 9       // 黄光恒亮开关接口
#define BlueSelect 10        // 蓝光恒亮开关接口
#define WhiteSelect 11       // 白光恒亮开关接口
#define ShowOptionsBit0 A8   // Show Options switch bit 0 set to Arduino digit pin A8
#define ShowOptionsBit1 A10  // Show Options switch bit 1 set to Arduino digit pin A10
#define ShowOptionsBit2 A12  // Show Options switch bit 2 set to Arduino digit pin A12
#define ShowOptionsBit3 A14  // Show Options switch bit 3 set to Arduino digit pin A14

#define SW12Bit0 40
#define SW12Bit1 41
#define SW12Bit2 42
#define SW12Bit3 43
#define SW12Bit4 44
#define SW12Bit5 45
#define SW12Bit6 46
#define SW12Bit7 47

#define SW13Bit0 32
#define SW13Bit1 33
#define SW13Bit2 34
#define SW13Bit3 35
#define SW13Bit4 36
#define SW13Bit5 37
#define SW13Bit6 38
#define SW13Bit7 39

#define SW14Bit0 A0
#define SW14Bit1 A1
#define SW14Bit2 A2
#define SW14Bit3 A3
#define SW14Bit4 A4
#define SW14Bit5 A5
#define SW14Bit6 A6
#define SW14Bit7 A7

// Basic I/O function definition ***************************************************************************************
#define DckHi() bitSet(PORTH, _MCUDck0)
#define DckLo() bitClear(PORTH, _MCUDck0)
#define DckPulse() \
  DckHi(); \
  DckLo()
#define LatchHi() bitSet(PORTH, _MCULatch0)
#define LatchLo() bitClear(PORTH, _MCULatch0)
#define LatchPulse() \
  LatchHi(); \
  LatchLo()
#define DatLo() bitClear(PORTG, _MCUDi0)
#define DatHi() bitSet(PORTG, _MCUDi0)
#define DatSet(x, y) bitWrite(PORTG, _MCUDi0, bitRead(x, y))
#define DisablePWM() TCCR3B = 0
#define EnablePWM() TCCR3B = _BV(WGM33) | _BV(WGM32) | _BV(CS30)
// Image and Show Definitions ********************************************************************************
static unsigned char ShowsTheOrder, NewShowsTheOrder;  // Show Options （initial 0）
static unsigned char ScreenOutputIndex;
static unsigned char RunSpeed, NewRunSpeed;
static unsigned int LEDBrightBuf1[ScanQty][ChannelQty];
static unsigned int DiodesLOGOImageBuf1[ScanQty][ChannelQty];
static unsigned int FaultStatus1[32];
static bool Fault_Open1, Fault_Open2, Fault_Open3, Fault_Short1, Fault_Short2, Fault_Short3;
//static unsigned int ImageBuf1[ImageWidth][ScanQty];
// Program, Time, and Other Definitions ********************************************************************************
static unsigned char SwitchChangesFlag;
static unsigned int RCMD1;
static unsigned int RCMD2;
static unsigned int RCMD3;
static unsigned int RCMD4;
static unsigned int RCMD5;
static unsigned int RCMD6;
static unsigned int RCMD7;
static unsigned int RCMD8;
static unsigned int RCMD9;
static unsigned int GCMD1;
static unsigned int GCMD2;
static unsigned int GCMD3;
static unsigned int GCMD4;
static unsigned int GCMD5;
static unsigned int GCMD6;
static unsigned int GCMD7;
static unsigned int GCMD8;
static unsigned int GCMD9;
static unsigned int BCMD1;
static unsigned int BCMD2;
static unsigned int BCMD3;
static unsigned int BCMD4;
static unsigned int BCMD5;
static unsigned int BCMD6;
static unsigned int BCMD7;
static unsigned int BCMD8;
static unsigned int BCMD9;
const unsigned char DiodesLogo1[96] = { 0x0, 0x0, 0x0, 0x0, 0x00, 0x00,
                                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                        0x7F, 0x18, 0xF3, 0xFC, 0x7E, 0x3E,
                                        0x7F, 0x99, 0xF9, 0xFE, 0x7E, 0x7F,
                                        0x63, 0xDB, 0x9D, 0x8F, 0x60, 0xE7,
                                        0x61, 0xDB, 0x0C, 0x87, 0x60, 0xE6,
                                        0x60, 0xFE, 0x06, 0x83, 0xFE, 0xF0,
                                        0x00, 0x00, 0x00, 0x03, 0xFE, 0x7E,
                                        0x60, 0xFE, 0x06, 0x83, 0xFE, 0x1F,
                                        0x61, 0xDB, 0x0C, 0x87, 0x60, 0xC3,
                                        0x63, 0xDB, 0x9D, 0x8F, 0x60, 0xE7,
                                        0x7F, 0x99, 0xF9, 0xFE, 0x7E, 0x7E,
                                        0x7F, 0x18, 0xF3, 0xFC, 0x7E, 0x3C,
                                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
const unsigned char Fon_OPEN[96] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                     0x00, 0x38, 0x78, 0x7C, 0x6E, 0x00,
                                     0x00, 0x44, 0x24, 0x24, 0x24, 0x00,
                                     0x00, 0x44, 0x24, 0x28, 0x34, 0x00,
                                     0x00, 0x44, 0x38, 0x38, 0x34, 0x00,
                                     0x00, 0x44, 0x20, 0x28, 0x2C, 0x00,
                                     0x00, 0x44, 0x20, 0x20, 0x2C, 0x00,
                                     0x00, 0x44, 0x20, 0x24, 0x24, 0x00,
                                     0x00, 0x38, 0x70, 0x7C, 0x76, 0x00,
                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
const unsigned char Fon_OPEN48S1[96] = { 0x38, 0x78, 0x7C, 0x6E, 0x01, 0xC0,
                                         0x44, 0x24, 0x24, 0x24, 0x02, 0x20,
                                         0x44, 0x24, 0x28, 0x34, 0x04, 0x90,
                                         0x44, 0x38, 0x38, 0x34, 0x05, 0x50,
                                         0x44, 0x20, 0x28, 0x2C, 0x05, 0x50,
                                         0x44, 0x20, 0x20, 0x2C, 0x04, 0xE0,
                                         0x44, 0x20, 0x24, 0x24, 0x02, 0x00,
                                         0x38, 0x70, 0x7C, 0x76, 0x01, 0xF0,
                                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                         0x04, 0x3C, 0x1C, 0x08, 0x00, 0x00,
                                         0x0C, 0x42, 0x22, 0x38, 0x00, 0x00,
                                         0x14, 0x66, 0x20, 0x08, 0x00, 0x00,
                                         0x24, 0x3C, 0x1C, 0x08, 0x00, 0x00,
                                         0x7F, 0x66, 0x02, 0x08, 0x00, 0x00,
                                         0x04, 0x42, 0x22, 0x08, 0x00, 0x00,
                                         0x04, 0x3C, 0x1C, 0x3E, 0x00, 0x00 };
const unsigned char Fon_OPEN46S3[96] = { 0x38, 0x78, 0x7C, 0x6E, 0x01, 0xC0,
                                         0x44, 0x24, 0x24, 0x24, 0x02, 0x20,
                                         0x44, 0x24, 0x28, 0x34, 0x04, 0x90,
                                         0x44, 0x38, 0x38, 0x34, 0x05, 0x50,
                                         0x44, 0x20, 0x28, 0x2C, 0x05, 0x50,
                                         0x44, 0x20, 0x20, 0x2C, 0x04, 0xE0,
                                         0x44, 0x20, 0x24, 0x24, 0x02, 0x00,
                                         0x38, 0x70, 0x7C, 0x76, 0x01, 0xF0,
                                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                         0x04, 0x1E, 0x1C, 0x1C, 0x00, 0x00,
                                         0x0C, 0x20, 0x22, 0x22, 0x00, 0x00,
                                         0x14, 0x40, 0x20, 0x02, 0x00, 0x00,
                                         0x24, 0x7C, 0x1C, 0x0C, 0x00, 0x00,
                                         0x7F, 0x42, 0x02, 0x02, 0x00, 0x00,
                                         0x04, 0x42, 0x22, 0x22, 0x00, 0x00,
                                         0x04, 0x3C, 0x1C, 0x1C, 0x00, 0x00 };
const unsigned char Fon_Short[96] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                      0x3C, 0x66, 0x38, 0x78, 0x7C, 0x00,
                                      0x44, 0x24, 0x44, 0x24, 0x54, 0x00,
                                      0x40, 0x24, 0x44, 0x24, 0x10, 0x00,
                                      0x30, 0x3C, 0x44, 0x38, 0x10, 0x00,
                                      0x08, 0x24, 0x44, 0x28, 0x10, 0x00,
                                      0x04, 0x24, 0x44, 0x24, 0x10, 0x00,
                                      0x44, 0x24, 0x44, 0x24, 0x10, 0x00,
                                      0x78, 0x66, 0x38, 0x76, 0x38, 0x00,
                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
const unsigned char Fon_Short36S8[96] = { 0x3C, 0xCC, 0x71, 0xE1, 0xF1, 0xC0,
                                          0x44, 0x48, 0x88, 0x91, 0x52, 0x20,
                                          0x40, 0x48, 0x88, 0x90, 0x44, 0x90,
                                          0x30, 0x78, 0x88, 0xE0, 0x45, 0x50,
                                          0x08, 0x48, 0x88, 0xA0, 0x45, 0x50,
                                          0x04, 0x48, 0x88, 0x90, 0x44, 0xE0,
                                          0x44, 0x48, 0x88, 0x90, 0x42, 0x00,
                                          0x78, 0xCC, 0x71, 0xD8, 0xE1, 0xF0,
                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                          0x1C, 0x1E, 0x1C, 0x3C, 0x00, 0x00,
                                          0x22, 0x20, 0x22, 0x42, 0x00, 0x00,
                                          0x02, 0x40, 0x20, 0x66, 0x00, 0x00,
                                          0x0C, 0x7C, 0x1C, 0x3C, 0x00, 0x00,
                                          0x02, 0x42, 0x02, 0x66, 0x00, 0x00,
                                          0x22, 0x42, 0x22, 0x42, 0x00, 0x00,
                                          0x1C, 0x3C, 0x1C, 0x3C, 0x00, 0x00 };
const unsigned char Fon_Short48S13[96] = { 0x3C, 0xCC, 0x71, 0xE1, 0xF1, 0xC0,
                                           0x44, 0x48, 0x88, 0x91, 0x52, 0x20,
                                           0x40, 0x48, 0x88, 0x90, 0x44, 0x90,
                                           0x30, 0x78, 0x88, 0xE0, 0x45, 0x50,
                                           0x08, 0x48, 0x88, 0xA0, 0x45, 0x50,
                                           0x04, 0x48, 0x88, 0x90, 0x44, 0xE0,
                                           0x44, 0x48, 0x88, 0x90, 0x42, 0x00,
                                           0x78, 0xCC, 0x71, 0xD8, 0xE1, 0xF0,
                                           0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                           0x04, 0x3C, 0x1C, 0x08, 0x1C, 0x00,
                                           0x0C, 0x42, 0x22, 0x38, 0x22, 0x00,
                                           0x14, 0x66, 0x20, 0x08, 0x02, 0x00,
                                           0x24, 0x3C, 0x1C, 0x08, 0x0C, 0x00,
                                           0x7F, 0x66, 0x02, 0x08, 0x02, 0x00,
                                           0x04, 0x42, 0x22, 0x08, 0x22, 0x00,
                                           0x04, 0x3C, 0x1C, 0x3E, 0x1C, 0x00 };
const unsigned char Fon_LEDisNormal[96] = { 0x70, 0x7C, 0x78, 0x07, 0xC3, 0x80,
                                            0x20, 0x24, 0x24, 0x01, 0x04, 0x40,
                                            0x20, 0x28, 0x24, 0x01, 0x04, 0x00,
                                            0x20, 0x38, 0x24, 0x01, 0x03, 0x00,
                                            0x20, 0x28, 0x24, 0x01, 0x00, 0x80,
                                            0x20, 0x20, 0x24, 0x01, 0x00, 0x40,
                                            0x22, 0x24, 0x24, 0x01, 0x04, 0x40,
                                            0x7E, 0x7C, 0x78, 0x07, 0xC3, 0x80,
                                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                            0xc7, 0x38, 0xF8, 0x82, 0x40, 0x00,
                                            0x62, 0x44, 0x84, 0xC6, 0x40, 0x00,
                                            0x52, 0x44, 0x84, 0xAA, 0x40, 0x00,
                                            0x4A, 0x44, 0xF8, 0xAA, 0x40, 0x00,
                                            0x46, 0x44, 0x88, 0x92, 0x40, 0x00,
                                            0x46, 0x44, 0x84, 0x92, 0x40, 0x00,
                                            0xE3, 0x38, 0x82, 0x82, 0x7E, 0x00 };
// *********************************************************************************************************************
void ShiftDatOut(int y0) {
  DckLo();
  DatSet(y0, 15);
  DckHi();
  DatSet(y0, 14);
  DckLo();
  DatSet(y0, 13);
  DckHi();
  DatSet(y0, 12);
  DckLo();
  DatSet(y0, 11);
  DckHi();
  DatSet(y0, 10);
  DckLo();
  DatSet(y0, 9);
  DckHi();
  DatSet(y0, 8);
  DckLo();
  DatSet(y0, 7);
  DckHi();
  DatSet(y0, 6);
  DckLo();
  DatSet(y0, 5);
  DckHi();
  DatSet(y0, 4);
  DckLo();
  DatSet(y0, 3);
  DckHi();
  DatSet(y0, 2);
  DckLo();
  DatSet(y0, 1);
  DckHi();
  DatSet(y0, 0);
  DckLo();
}
// CMD1 Set up**********************************************************************************************************
void CMD1Seting(void) {
  ShiftDatOut(RCMD1);
  ShiftDatOut(GCMD1);
  ShiftDatOut(BCMD1);
  LatchPulse();
}
// CMD2 Set up**********************************************************************************************************
void CMD2Seting(void) {
  ShiftDatOut(RCMD2);
  ShiftDatOut(GCMD2);
  ShiftDatOut(BCMD2);
  LatchPulse();
}
// CMD3 Set up**********************************************************************************************************
void CMD3Seting(void) {
  ShiftDatOut(RCMD3);
  ShiftDatOut(GCMD3);
  ShiftDatOut(BCMD3);
  LatchPulse();
}
// CMD3 Set up**********************************************************************************************************
void CMD4Seting(void) {
  ShiftDatOut(RCMD4);
  ShiftDatOut(GCMD4);
  ShiftDatOut(BCMD4);
  LatchPulse();
}
// *********************************************************************************************************************
void CMD5Seting(void) {
  ShiftDatOut(RCMD5);
  ShiftDatOut(GCMD5);
  ShiftDatOut(BCMD5);
  LatchPulse();
}
// *********************************************************************************************************************
void CMD6Seting(void) {
  ShiftDatOut(RCMD6);
  ShiftDatOut(GCMD6);
  ShiftDatOut(BCMD6);
  LatchPulse();
}
// *********************************************************************************************************************
void CMD7Seting(void) {
  ShiftDatOut(RCMD7);
  ShiftDatOut(GCMD7);
  ShiftDatOut(BCMD7);
  LatchPulse();
}
// *********************************************************************************************************************
void CMD8Seting(void) {
  ShiftDatOut(RCMD8);
  ShiftDatOut(GCMD8);
  ShiftDatOut(BCMD8);
  LatchPulse();
}
// *********************************************************************************************************************
void CMD9Seting(void) {
  ShiftDatOut(RCMD9);
  ShiftDatOut(GCMD9);
  ShiftDatOut(BCMD9);
  LatchPulse();
}
// *********************************************************************************************************************
void ScreenOutput(void) {
  switch (ScreenOutputIndex) {
    case 1:
      DckLo();
      LatchHi();
      DisablePWM();
      for (unsigned char i = 0; i < 6; i++) {
        DckPulse();
      }
      LatchLo();
      EnablePWM();
      CMD1Seting();
      CMD2Seting();
      CMD3Seting();
      for (unsigned int j = 0; j < ScanQty; j++) {
        for (unsigned int i = 0; i < ChannelQty; i++) { ShiftDatOut(LEDBrightBuf1[j][i]); }
        LatchPulse();
      }
      ScreenOutputIndex = 2;
      break;

    case 2:
      DckLo();
      LatchHi();
      DisablePWM();
      for (unsigned char i = 0; i < 6; i++) {
        DckPulse();
      }
      LatchLo();
      EnablePWM();
      CMD1Seting();
      CMD2Seting();
      CMD4Seting();
      for (unsigned int j = 0; j < ScanQty; j++) {
        for (unsigned int i = 0; i < ChannelQty; i++) { ShiftDatOut(LEDBrightBuf1[j][i]); }
        LatchPulse();
      }
      ScreenOutputIndex = 3;
      break;

    case 3:
      DckLo();
      LatchHi();
      DisablePWM();
      for (unsigned char i = 0; i < 6; i++) {
        DckPulse();
      }
      LatchLo();
      EnablePWM();
      CMD1Seting();
      CMD2Seting();
      CMD5Seting();
      for (unsigned int j = 0; j < ScanQty; j++) {
        for (unsigned int i = 0; i < ChannelQty; i++) { ShiftDatOut(LEDBrightBuf1[j][i]); }
        LatchPulse();
      }
      ScreenOutputIndex = 4;
      break;
    case 4:
      DckLo();
      LatchHi();
      DisablePWM();
      for (unsigned char i = 0; i < 6; i++) {
        DckPulse();
      }
      LatchLo();
      EnablePWM();
      CMD1Seting();
      CMD2Seting();
      CMD6Seting();
      for (unsigned int j = 0; j < ScanQty; j++) {
        for (unsigned int i = 0; i < ChannelQty; i++) { ShiftDatOut(LEDBrightBuf1[j][i]); }
        LatchPulse();
      }
      ScreenOutputIndex = 1;
      break;

    default:
      DckLo();
      LatchHi();
      DisablePWM();
      for (unsigned char i = 0; i < 6; i++) {
        DckPulse();
      }
      LatchLo();
      EnablePWM();
      CMD1Seting();
      CMD2Seting();
      CMD6Seting();
      for (unsigned int j = 0; j < ScanQty; j++) {
        for (unsigned int i = 0; i < ChannelQty; i++) { ShiftDatOut(LEDBrightBuf1[j][i]); }
        LatchPulse();
      }
      ScreenOutputIndex = 1;
      break;
  }
}
// *********************************************************************************************************************
void OpenDetection1(void) {
  RCMD1 = 0x3fc1;  // 扫描数: 16，刷新：8X，低灰均匀：0b01，灰阶选择:16bit，补偿时间(最高位)：0，GCK 倍频：开启
  GCMD1 = 0x00;    //扫描模式：0b0000，扫描顺序：0b0000，B补偿粗调节：0b00，R 补偿细调节：0b00，G补偿细调节：0b00，B 补偿细调节：0b00，：，：，：，：，：，
  BCMD1 = 0x0f;
  RCMD2 = 0x6854;  //上行消影6，消影时间8，补偿时间(低4 位)5，开路十字消除b00 关闭，R侦测准位b00
  GCMD2 = 0x0;
  BCMD2 = 0x0;
  RCMD3 = 0xff;
  GCMD3 = 0xff;
  BCMD3 = 0xff;
  RCMD4 = 0x4000;
  GCMD4 = 0x4000;
  BCMD4 = 0x4000;
  RCMD5 = 0x9014;
  GCMD5 = 0x9014;
  BCMD5 = 0x9014;
  RCMD6 = 0xc7C1;
  GCMD6 = 0xc3C1;
  BCMD6 = 0xc3C1;
  RCMD7 = 0x3F51;

  bitWrite(RCMD2, 0, digitalRead(RCMD20));
  bitWrite(RCMD2, 1, digitalRead(RCMD21));
  bitWrite(GCMD2, 0, digitalRead(GCMD20));
  bitWrite(GCMD2, 1, digitalRead(GCMD21));
  bitWrite(BCMD2, 0, digitalRead(BCMD20));
  bitWrite(BCMD2, 1, digitalRead(BCMD21));

  for (unsigned char k = 0; k < 12; k++) {
    DckLo();
    LatchHi();
    DisablePWM();
    for (unsigned char i = 0; i < 6; i++) {
      DckPulse();
    }
    LatchLo();
    EnablePWM();
    CMD1Seting();
    CMD2Seting();
    CMD3Seting();
    for (unsigned int j = 0; j < ScanQty; j++) {
      for (unsigned int i = 0; i < ChannelQty; i++) { ShiftDatOut(0x4000); }
      LatchPulse();
    }
  }

  DatLo();
  LatchHi();
  DisablePWM();
  for (unsigned char i = 0; i < 10; i++) {
    DckPulse();
  }

  LatchLo();
  EnablePWM();
  Fault_Open1 = false;
  Fault_Open2 = false;
  Fault_Open3 = false;
  for (unsigned int j = 0; j < 32; j++) {
    for (unsigned int i = 0; i < 48; i++) {
      if ((i % 2) == 0) {
        DckHi();
      } else {
        DckLo();
      }
      if (digitalRead(Do0)) {
        switch (j) {
          case 0:
            Fault_Open1 = true;
            break;
          case 1:
            Fault_Open2 = true;
            break;
          default:
            Fault_Open3 = true;
        }
      }
    }
  }
  
 // for (unsigned int i = 0; i < 32; i++) { CMD1Seting(); }

  if (Fault_Open1) {
    for (unsigned char k = 0; k < 60; k++) {
      DisplayOpen48S1();
    }
  }
  if (Fault_Open2) {
    for (unsigned char k = 0; k < 60; k++) {
      DisplayOpen46S3();
    }
  }
  if (Fault_Open3) {
    for (unsigned char k = 0; k < 60; k++) {
      DisplayOpen();
    }
  }
  if (!Fault_Open1 & !Fault_Open2 & !Fault_Open3) {
    for (unsigned char k = 0; k < 60; k++) {
      DisplayLEDisNormal();
    }
  }
}
// *********************************************************************************************************************
void ShortDetect(void) {
  RCMD1 = 0x3fc1;  // 扫描数: 16，刷新：8X，低灰均匀：0b01，灰阶选择:16bit，补偿时间(最高位)：0，GCK 倍频：开启
  GCMD1 = 0x00;    //扫描模式：0b0000，扫描顺序：0b0000，B补偿粗调节：0b00，R 补偿细调节：0b00，G补偿细调节：0b00，B 补偿细调节：0b00，：，：，：，：，：，
  BCMD1 = 0x0f;
  RCMD2 = 0x6854;  //上行消影6，消影时间8，补偿时间(低4 位)5，开路十字消除b00 关闭，R侦测准位b00
  GCMD2 = 0x0;
  BCMD2 = 0x0;
  RCMD3 = 0xff;
  GCMD3 = 0xff;
  BCMD3 = 0xff;
  RCMD4 = 0x4000;
  GCMD4 = 0x4000;
  BCMD4 = 0x4000;
  RCMD5 = 0x9014;
  GCMD5 = 0x9014;
  BCMD5 = 0x9014;
  RCMD6 = 0xc7C1;
  GCMD6 = 0xc3C1;
  BCMD6 = 0xc3C1;
  RCMD7 = 0x3F51;

  bitWrite(RCMD2, 0, digitalRead(RCMD20));
  bitWrite(RCMD2, 1, digitalRead(RCMD21));
  bitWrite(GCMD2, 0, digitalRead(GCMD20));
  bitWrite(GCMD2, 1, digitalRead(GCMD21));
  bitWrite(BCMD2, 0, digitalRead(BCMD20));
  bitWrite(BCMD2, 1, digitalRead(BCMD21));
  // LED Opening detection ************************************
  DckLo();
  LatchHi();
  DisablePWM();
  for (unsigned char i = 0; i < 6; i++) {
    DckPulse();
  }
  LatchLo();
  EnablePWM();
  CMD1Seting();
  CMD2Seting();
  CMD3Seting();
  for (unsigned int j = 0; j < ScanQty; j++) {
    for (unsigned int i = 0; i < ChannelQty; i++) { ShiftDatOut(0x4000); }
    LatchPulse();
  }
  RCMD2 = 0x6850;
  for (unsigned char k = 0; k < 11; k++) {
    DckLo();
    LatchHi();
    DisablePWM();
    for (unsigned char i = 0; i < 6; i++) {
      DckPulse();
    }
    LatchLo();
    EnablePWM();
    CMD1Seting();
    CMD2Seting();
    CMD3Seting();
    for (unsigned int j = 0; j < ScanQty; j++) {
      for (unsigned int i = 0; i < ChannelQty; i++) { ShiftDatOut(0x4000); }
      LatchPulse();
    }
  }

  DatLo();
  LatchHi();
  DisablePWM();
  for (unsigned char i = 0; i < 10; i++) {
    DckPulse();
  }

  LatchLo();
  EnablePWM();
  Fault_Short1 = false;
  Fault_Short2 = false;
  Fault_Short3 = false;
  for (unsigned int j = 0; j < 32; j++) {
    for (unsigned int i = 0; i < 48; i++) {
      if ((i % 2) == 0) {
        DckHi();
      } else {
        DckLo();
      }
      if (digitalRead(Do0)) {
        switch (j) {
          case 8:
            Fault_Short1 = true;
            break;
          case 0:
            Fault_Short2 = true;
            break;
          default:
            Fault_Short3 = true;
        }
      }
    }
  }
  // for (unsigned int i = 0; i < 32; i++) { CMD1Seting(); }

  if (Fault_Short1) {
    for (unsigned char k = 0; k < 60; k++) {
      DisplayShort36S8();
    }
  }
  if (Fault_Short2) {
    for (unsigned char k = 0; k < 60; k++) {
      DisplayShort48S13();
    }
  }
  if (Fault_Short3) {
    for (unsigned char k = 0; k < 60; k++) {
      DisplayShort();
    }
  }
  if (!Fault_Short1 & !Fault_Short2 & !Fault_Short3) {
    for (unsigned char k = 0; k < 60; k++) {
      DisplayLEDisNormal();
    }
  }
}
// *********************************************************************************************************************
void CleanLEDBrightBuf1(void) {
  for (unsigned int j = 0; j < ScanQty; j++) {
    for (unsigned int i = 0; i < ChannelQty; i++) {
      LEDBrightBuf1[j][i] = 0;
    }
  }
}
// *********************************************************************************************************************
void EnableExternalGckOutput(void) {
  OCR3A = 1;  // Top value A ,PWM Frequency = PWM CLK / (OCR3A+1)
  OCR3B = 0;  // Toggle value B, Duty = (OCR3B + 1)/(OCR3A + 1)
  TCCR3A = 0;
  TCCR3A = _BV(COM3A0) | _BV(COM3B1) | _BV(WGM31) | _BV(WGM30);  // Set to varying top limit fast PWM mode
  TCCR3B = 0;
  TCCR3B = _BV(WGM33) | _BV(WGM32) | _BV(CS30);  // Waveform Generation Mode 15；another way to set prescaler （Clock Select Bit Description 2 ）CS2= 1 , PWM CLK = 16MHz / 1 =16MHZ
}
// *********************************************************************************************************************
void ReadSwitch(void) {
  RCMD1 = 0x3fc1;  // 扫描数: 16，刷新：8X，低灰均匀：0b01，灰阶选择:16bit，补偿时间(最高位)：0，GCK 倍频：开启
  GCMD1 = 0x00;    //扫描模式：0b0000，扫描顺序：0b0000，B补偿粗调节：0b00，R 补偿细调节：0b00，G补偿细调节：0b00，B 补偿细调节：0b00，：，：，：，：，：，
  BCMD1 = 0x0f;
  RCMD2 = 0x6856;  //上行消影6，消影时间8，补偿时间(低4 位)5，开路十字消除b00 关闭，R侦测准位b00
  GCMD2 = 0x0;
  BCMD2 = 0x0;
  RCMD3 = 0xfc;
  GCMD3 = 0xfc;
  BCMD3 = 0xfc;
  RCMD4 = 0x4000;
  GCMD4 = 0x4000;
  BCMD4 = 0x4000;
  RCMD5 = 0x9014;
  GCMD5 = 0x9014;
  BCMD5 = 0x9014;
  RCMD6 = 0xc7C1;
  GCMD6 = 0xc3C1;
  BCMD6 = 0xc3C1;
  RCMD7 = 0x3F51;
  GCMD7 = 0;
  BCMD7 = 0x0f;
  RCMD8 = 0;
  GCMD8 = 0;
  BCMD8 = 0;
  RCMD9 = 0;
  GCMD9 = 0;
  BCMD9 = 0;

  bitWrite(RCMD2, 0, digitalRead(RCMD20));
  bitWrite(RCMD2, 1, digitalRead(RCMD21));
  bitWrite(GCMD2, 0, digitalRead(GCMD20));
  bitWrite(GCMD2, 1, digitalRead(GCMD21));
  bitWrite(BCMD2, 0, digitalRead(BCMD20));
  bitWrite(BCMD2, 1, digitalRead(BCMD21));
  // Sleep mode  switching & settings **********************************************************************************
  bitWrite(RCMD3, 13, digitalRead(CMD3_13));
  bitWrite(GCMD3, 13, digitalRead(CMD3_13));
  bitWrite(BCMD3, 13, digitalRead(CMD3_13));
  // Dynamic power saving switching & settings**************************************************************************
  bitWrite(RCMD3, 12, digitalRead(CMD3_12));
  bitWrite(GCMD3, 12, digitalRead(CMD3_12));
  bitWrite(BCMD3, 12, digitalRead(CMD3_12));
  // Red GCC switching & settings (Red LED Current Gain) ***************************************************************
  bitWrite(RCMD3, 5, digitalRead(RGCC5));
  bitWrite(RCMD3, 4, digitalRead(RGCC4));
  bitWrite(RCMD3, 3, digitalRead(RGCC3));
  bitWrite(RCMD3, 2, digitalRead(RGCC2));
  bitWrite(RCMD3, 1, digitalRead(RGCC1));
  bitWrite(RCMD3, 0, digitalRead(RGCC0));
  // Green GCC switching & settings (Green LED Current Gain) ***********************************************************
  bitWrite(GCMD3, 5, digitalRead(GGCC5));
  bitWrite(GCMD3, 4, digitalRead(GGCC4));
  bitWrite(GCMD3, 3, digitalRead(GGCC3));
  bitWrite(GCMD3, 2, digitalRead(GGCC2));
  bitWrite(GCMD3, 1, digitalRead(GGCC1));
  bitWrite(GCMD3, 0, digitalRead(GGCC0));
  // Blue GCC switching & settings (Blue LED Current Gain) *************************************************************
  bitWrite(BCMD3, 5, digitalRead(BGCC5));
  bitWrite(BCMD3, 4, digitalRead(BGCC4));
  bitWrite(BCMD3, 3, digitalRead(BGCC3));
  bitWrite(BCMD3, 2, digitalRead(BGCC2));
  bitWrite(BCMD3, 1, digitalRead(BGCC1));
  bitWrite(BCMD3, 0, digitalRead(BGCC0));

  // Select Shows ********************************************************************************************************
  NewShowsTheOrder = 0;
  bitWrite(NewShowsTheOrder, 0, digitalRead(ShowOptionsBit0));
  bitWrite(NewShowsTheOrder, 1, digitalRead(ShowOptionsBit1));
  bitWrite(NewShowsTheOrder, 2, digitalRead(ShowOptionsBit2));
  bitWrite(NewShowsTheOrder, 3, digitalRead(ShowOptionsBit3));
  NewRunSpeed = 0;
  bitWrite(NewRunSpeed, 0, digitalRead(SW14Bit0));
  bitWrite(NewRunSpeed, 1, digitalRead(SW14Bit1));
  bitWrite(NewRunSpeed, 2, digitalRead(SW14Bit2));
  bitWrite(NewRunSpeed, 3, digitalRead(SW14Bit3));
  bitWrite(NewRunSpeed, 4, digitalRead(SW14Bit4));
  bitWrite(NewRunSpeed, 5, digitalRead(SW14Bit5));
  bitWrite(NewRunSpeed, 6, digitalRead(SW14Bit6));
  bitWrite(NewRunSpeed, 7, digitalRead(SW14Bit7));

  if (NewShowsTheOrder != ShowsTheOrder) {
    SwitchChangesFlag = HIGH;
    ShowsTheOrder = NewShowsTheOrder;
  }
  if (NewRunSpeed != RunSpeed) {
    RunSpeed = NewRunSpeed;
  }
}
// *********************************************************************************************************************
void TrunOFF(void) {
  CleanLEDBrightBuf1();
  ScreenOutput();
}
// DIODES LOGO 圖像轉亮度*********************************************************************************************************************
void GetDiodesLogoImage1(void) {
  for (unsigned int j = 0; j < 96; j++) {
    for (unsigned int i = 0; i < 8; i++) {
      if (bitRead(DiodesLogo1[j], 7 - i)) {
        DiodesLOGOImageBuf1[j / 6][(((j % 6) * 8) + i)] = 0xcfff;
      } else {
        DiodesLOGOImageBuf1[j / 6][(((j % 6) * 8) + i)] = 0;
      }
    }
  }
}

// *********************************************************************************************************************
void DisplayDiodesLogo1(void) {
  for (unsigned int j = 0; j < 96; j++) {
    for (unsigned int i = 0; i < 8; i++) {
      if (bitRead(DiodesLogo1[j], 7 - i)) {
        LEDBrightBuf1[j / 6][48 - (j % 6 * 8 + i)] = 0xcfff;
      } else {
        LEDBrightBuf1[j / 6][48 - (j % 6 * 8 + i)] = 0;
      }
    }
    ReadSwitch();
  }
  ScreenOutput();
  delay(RunSpeed + 1);

}
// *********************************************************************************************************************
void DisplayOpen48S1(void) {
  for (unsigned int j = 0; j < 96; j++) {
    for (unsigned int i = 0; i < 8; i++) {
      if (bitRead(Fon_OPEN48S1[j], 7 - i)) {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0xcfff;
      } else {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0;
      }
    }
    ReadSwitch();
  }
  ScreenOutput();
  delay(RunSpeed + 1);
}
// *********************************************************************************************************************
void DisplayOpen46S3(void) {
  for (unsigned int j = 0; j < 96; j++) {
    for (unsigned int i = 0; i < 8; i++) {
      if (bitRead(Fon_OPEN46S3[j], 7 - i)) {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0xcfff;
      } else {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0;
      }
    }
    ReadSwitch();
  }
  ScreenOutput();
  delay(RunSpeed + 1);
}
// *********************************************************************************************************************
void DisplayOpen(void) {
  for (unsigned int j = 0; j < 96; j++) {
    for (unsigned int i = 0; i < 8; i++) {
      if (bitRead(Fon_OPEN[j], 7 - i)) {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0xcfff;
      } else {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0;
      }
    }
    ReadSwitch();
  }
  ScreenOutput();
  delay(RunSpeed + 1);
}
// *********************************************************************************************************************
void DisplayShort(void) {
  for (unsigned int j = 0; j < 96; j++) {
    for (unsigned int i = 0; i < 8; i++) {
      if (bitRead(Fon_Short[j], 7 - i)) {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0xcfff;
      } else {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0;
      }
    }
    ReadSwitch();
  }
  ScreenOutput();
  delay(RunSpeed + 1);
}
// *********************************************************************************************************************
void DisplayShort48S13(void) {
  for (unsigned int j = 0; j < 96; j++) {
    for (unsigned int i = 0; i < 8; i++) {
      if (bitRead(Fon_Short48S13[j], 7 - i)) {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0xcfff;
      } else {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0;
      }
    }
    ReadSwitch();
  }
  ScreenOutput();
  delay(RunSpeed + 1);
}
// *********************************************************************************************************************
void DisplayShort36S8(void) {
  for (unsigned int j = 0; j < 96; j++) {
    for (unsigned int i = 0; i < 8; i++) {
      if (bitRead(Fon_Short36S8[j], 7 - i)) {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0xcfff;
      } else {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0;
      }
    }
    ReadSwitch();
  }
  ScreenOutput();
  delay(RunSpeed + 1);
}
// *********************************************************************************************************************
void DisplayLEDisNormal(void) {
  for (unsigned int j = 0; j < 96; j++) {
    for (unsigned int i = 0; i < 8; i++) {
      if (bitRead(Fon_LEDisNormal[j], 7 - i)) {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0xcfff;
      } else {
        LEDBrightBuf1[j / 6][47 - (j % 6 * 8 + i)] = 0;
      }
    }
    ReadSwitch();
  }
  ScreenOutput();
  delay(RunSpeed + 1);
}
// Fade In_Out*******************************************************************************************************
void Show1(void) {
  for (unsigned int n = 0; n < 100; n++) {
    //for (unsigned int m = 0; m < RunSpeed + 1; m++) {
    for (unsigned int m = 0; m < 4; m++) {

      for (unsigned int j = 0; j < 16; j++) {
        for (unsigned int i = 0; i < 48; i++) {
           LEDBrightBuf1[j][i] = n * 225;
        }
        ReadSwitch();
        if (SwitchChangesFlag) {
          SwitchChangesFlag = LOW;
          return;
        }
      }
      ScreenOutput();
    }
  }
  for (unsigned int n = 0; n < 101; n++) {
    //for (unsigned int m = 0; m < RunSpeed + 1; m++) {
    for (unsigned int m = 0; m < 4; m++) {
      for (unsigned int j = 0; j < 16; j++) {
        for (unsigned int i = 0; i < 48; i++) {
          LEDBrightBuf1[j][i] = (100 - n) * 225;
        }
        ReadSwitch();
        if (SwitchChangesFlag) {
          SwitchChangesFlag = LOW;
          return;
        }
      }
      ScreenOutput();
    }
  }
}
// Flash fade in_out*********************************************************************************************************************
void Show2(void) {
//  for (unsigned int n = 0; n < 200; n++) {
  for (unsigned int n = 0; n < 50; n++) {
    for (unsigned int m = 0; m < 8; m++) {

      for (unsigned int j = 0; j < 16; j++) {
        for (unsigned int i = 0; i < 48; i++) {
          unsigned int l = j;
          unsigned int k = i;
          if (l %= 2) {
            if (k %= 2) LEDBrightBuf1[j][i] = 0x000;
            else LEDBrightBuf1[j][i] = n * 655;
          } else {
            if (k %= 2) LEDBrightBuf1[j][i] = n * 655;
            else LEDBrightBuf1[j][i] = 0x000;
          }
        }
        ReadSwitch();
        if (SwitchChangesFlag) {
          SwitchChangesFlag = LOW;
          return;
        }
      }
      ScreenOutput();
    }

    for (unsigned int m = 0; m < 8; m++) {

      for (unsigned int j = 0; j < 16; j++) {
        for (unsigned int i = 0; i < 48; i++) {
          unsigned int l = j;
          unsigned int k = i;
          if (l %= 2) {
            if (k %= 2) LEDBrightBuf1[j][i] = n * 655;
            else LEDBrightBuf1[j][i] = 0x000;
          } else {
            if (k %= 2) LEDBrightBuf1[j][i] = 0x000;
            else LEDBrightBuf1[j][i] = n * 655;
          }
        }
        ReadSwitch();
        if (SwitchChangesFlag) {
          SwitchChangesFlag = LOW;
          return;
        }
      }
      ScreenOutput();
    } 
  }


  for (unsigned int n = 50; n > 0; n--) {
    for (unsigned int m = 0; m < 8; m++) {

      for (unsigned int j = 0; j < 16; j++) {
        for (unsigned int i = 0; i < 48; i++) {
          unsigned int l = j;
          unsigned int k = i;
          if (l %= 2) {
            if (k %= 2) LEDBrightBuf1[j][i] = 0x000;
            else LEDBrightBuf1[j][i] = n * 655;
          } else {
            if (k %= 2) LEDBrightBuf1[j][i] = n * 655;
            else LEDBrightBuf1[j][i] = 0x000;
          }
        }
        ReadSwitch();
        if (SwitchChangesFlag) {
          SwitchChangesFlag = LOW;
          return;
        }
      }
      ScreenOutput();
    }
    for (unsigned int m = 0; m < 8; m++) {

      for (unsigned int j = 0; j < 16; j++) {
        for (unsigned int i = 0; i < 48; i++) {
          unsigned int l = j;
          unsigned int k = i;
          if (l %= 2) {
            if (k %= 2) LEDBrightBuf1[j][i] = n * 655;
            else LEDBrightBuf1[j][i] = 0x000;
          } else {
            if (k %= 2) LEDBrightBuf1[j][i] = 0x000;
            else LEDBrightBuf1[j][i] = n * 655;
          }
        }
        ReadSwitch();
        if (SwitchChangesFlag) {
          SwitchChangesFlag = LOW;
          return;
        }
      }
      ScreenOutput();
    }  
  }
}
// 斜線(左下右上)*******************************************************************************************************
void Show3(void) {
  CleanLEDBrightBuf1();
  for (unsigned int i = 0; i < 48; i++) {
    LEDBrightBuf1[i % 16][i] = 0xffff;
  }
  ScreenOutput();
}
// 斜線(左上右下)*******************************************************************************************************
void Show4(void) {
  CleanLEDBrightBuf1();
  for (unsigned int i = 0; i < 48; i++) {
    LEDBrightBuf1[15 - (i % 16)][i] = 0xffff;
  }
  ScreenOutput();
}
// 灰漸層*********************************************************************************************************************
void Show5(void) {
  unsigned int k;
  k = 65535;
  for (unsigned int j = 0; j < 48; j++) {
    for (unsigned int i = 0; i < 16; i++) {
      LEDBrightBuf1[i][47 - j] = k;
    }
   k -= 1261;
  }
  ScreenOutput();
  delay(75);
}
// gamma 2.2漸層*********************************************************************************************************************
void Show6(void) {
  float p1, e1;
  double k;
  k = 65535;
  p1 = 0.97758;
  e1 = 2.2;
  for (unsigned int j = 0; j < 48; j++) {
    for (unsigned int i = 0; i < 16; i++) {
      LEDBrightBuf1[i][47 - j] = int(k);
    }
    k *= pow(p1, e1);
  }
  ScreenOutput();
  delay(75);
}
// gamma 2.6漸層*********************************************************************************************************************
void Show7(void) {
  float p1, e1;
  double k;
  k = 65535;
  p1 = 0.981;  //0.9825;
  e1 = 2.6;
  for (unsigned int j = 0; j < 48; j++) {
    for (unsigned int i = 0; i < 16; i++) {
      LEDBrightBuf1[i][47 - j] = int(k);
    }
    k *= pow(p1, e1);
  }
  ScreenOutput();
  delay(75);
}
// DIODES LOGO 向左跑動*********************************************************************************************************************
void RunningDiodesLogo1(void) {

  for (unsigned int m = 0; m < ChannelQty; m++) {
    for (unsigned int i = 0; i < ChannelQty; i++) {
      for (unsigned int j = 0; j < ScanQty; j++) {
        if ((i + m) < ChannelQty) {
          LEDBrightBuf1[j][48 - i - 1] = 0;
        } else {
          LEDBrightBuf1[j][48 - i - 1] = DiodesLOGOImageBuf1[j - 1][i + m];
        }
      }
    }
    ScreenOutput();
    //for (unsigned int i = 0; i < (RunSpeed + 1); i++) {
    for (unsigned int i = 0; i < (RunSpeed + 60); i++) {
      ReadSwitch();
      if (SwitchChangesFlag) {
        SwitchChangesFlag = LOW;
        return;
      }
    }
  }
  for (unsigned int m = 0; m < ChannelQty; m++) {
    for (unsigned int i = 0; i < ChannelQty; i++) {
      for (unsigned int j = 0; j < ScanQty; j++) {
        if ((i + m) < ChannelQty) {
          LEDBrightBuf1[j][48 - i - 1] = DiodesLOGOImageBuf1[j][i + m];
        } else {
          LEDBrightBuf1[j][48 - i - 1] = 0;
        }
      }
    }
    ScreenOutput();
    //for (unsigned int i = 0; i < (RunSpeed + 1); i++) {
    for (unsigned int i = 0; i < (RunSpeed + 60); i++) {
      ReadSwitch();
      if (SwitchChangesFlag) {
        SwitchChangesFlag = LOW;
        return;
      }
    }
  }
}
// DIODES LOGO 上方閃入*********************************************************************************************************************
void UpFlashInDiodesLogo1(void) {

  for (unsigned int j = 0; j < ScanQty; j++) {
    for (unsigned int i = 0; i < ChannelQty; i++) {
      LEDBrightBuf1[j][48 - i] = DiodesLOGOImageBuf1[j][i];
    }
    ReadSwitch();
    ScreenOutput();
    //delay(RunSpeed + 1);
    delay(RunSpeed + 75);
  }
}
// DIODES LOGO 左側閃入*********************************************************************************************************************
void LeftFlashInDiodesLogo1(void) {

  for (unsigned int j = 0; j < ChannelQty; j++) {
    for (unsigned int i = 0; i < ScanQty; i++) {
      LEDBrightBuf1[i][48 - j] = DiodesLOGOImageBuf1[i][j];
    }
    ReadSwitch();
    ScreenOutput();
    //delay(RunSpeed + 1);
    delay(RunSpeed + 20);
  }
}
// *********************************************************************************************************************
void AllLight(void) {
  for (unsigned int j = 0; j < 16; j++) {
    for (unsigned int i = 0; i < 48; i++) {
      LEDBrightBuf1[j][i] = 0xcfff;
    }
  }
  ScreenOutput();
}
// *********************************************************************************************************************
void setup() {
  bitSet(DDRG, _MCUDi0);     // Di0 set to output (Used for fast I/O task requirements)
  bitSet(DDRH, _MCUDck0);    // Dck0 set to output (Used for fast I/O task requirements)
  bitSet(DDRH, _MCULatch0);  // Latch0 set to output (Used for fast I/O task requirements)
  pinMode(Gck0, OUTPUT);

  pinMode(Do0, INPUT);
  //bitSet(DDRE, _MCUDo0);

  pinMode(CMD3_12, INPUT);
  pinMode(CMD3_13, INPUT);
  pinMode(BCMD21, INPUT);
  pinMode(RCMD21, INPUT);
  pinMode(GCMD20, INPUT);
  pinMode(GCMD21, INPUT);
  pinMode(BCMD20, INPUT);
  pinMode(BCMD21, INPUT);
  pinMode(RGCC0, INPUT);
  pinMode(RGCC1, INPUT);
  pinMode(RGCC2, INPUT);
  pinMode(RGCC3, INPUT);
  pinMode(RGCC4, INPUT);
  pinMode(RGCC5, INPUT);
  pinMode(GGCC0, INPUT);
  pinMode(GGCC1, INPUT);
  pinMode(GGCC2, INPUT);
  pinMode(GGCC3, INPUT);
  pinMode(GGCC4, INPUT);
  pinMode(GGCC5, INPUT);
  pinMode(BGCC0, INPUT);
  pinMode(BGCC1, INPUT);
  pinMode(BGCC2, INPUT);
  pinMode(BGCC3, INPUT);
  pinMode(BGCC4, INPUT);
  pinMode(BGCC5, INPUT);
  pinMode(ShowOptionsBit0, INPUT_PULLUP);
  pinMode(ShowOptionsBit1, INPUT_PULLUP);
  pinMode(ShowOptionsBit2, INPUT_PULLUP);
  pinMode(ShowOptionsBit3, INPUT_PULLUP);
  pinMode(SW14Bit0, INPUT_PULLUP);
  pinMode(SW14Bit1, INPUT_PULLUP);
  pinMode(SW14Bit2, INPUT_PULLUP);
  pinMode(SW14Bit3, INPUT_PULLUP);
  pinMode(SW14Bit4, INPUT_PULLUP);
  pinMode(SW14Bit5, INPUT_PULLUP);
  pinMode(SW14Bit6, INPUT_PULLUP);
  pinMode(SW14Bit7, INPUT_PULLUP);
  ScreenOutputIndex = 1;
  EnableExternalGckOutput();
  //CleanImageBuf1();
  CleanLEDBrightBuf1();
  ScreenOutput();
  ScreenOutput();
  ScreenOutput();
  ScreenOutput();
  ScreenOutput();
  SwitchChangesFlag = LOW;
  GetDiodesLogoImage1();
}
// *********************************************************************************************************************
void loop() {
  while (1) {
    ReadSwitch();
    CleanLEDBrightBuf1();
    switch (ShowsTheOrder) {
      case 0:
        DisplayDiodesLogo1();
        break;
      case 1:
        AllLight();
        break;
      case 2:
        Show1();
        break;
      case 3:
        Show2();
        break;
      case 4:
        Show3();
        break;
      case 5:
        Show4();
        break;
      case 6:
        Show5();
        break;
      case 7:
        Show7();
        break;
      case 8:
        RunningDiodesLogo1();
        break;
      case 9:
        UpFlashInDiodesLogo1();
        break;
      case 10:
        LeftFlashInDiodesLogo1();
        break;
      case 11:
        TrunOFF();
        break;
      case 12:
        TrunOFF();
        break;
      case 13:
        TrunOFF();
        break;
      case 14:
        OpenDetection1();
        break;
      case 15:
        ShortDetect();
        break;
      default:
        TrunOFF();
        break;
    }
  }
}
